/**
 * 文件系统导入工具
 * 处理文件结构到小说结构的转换和导入
 */
import { NovelStructure, FileHandle } from '../../types/fileSystem.ts';
import { TreeItem, ItemType, Novel, Volume, Chapter } from '../../types/novel.ts';
import { preserveTextFormat } from './textFormatUtils.ts';
import { registerFileHandle } from '../file/fileSystem.ts';

/**
 * 将文件系统结构转换为小说树结构
 * @param structure 文件系统结构
 * @returns 小说树结构
 */
export async function convertToNovelTree(structure: NovelStructure): Promise<Novel> {
    if (!structure || !structure.rootFolder) {
        throw new Error('无效的文件系统结构');
    }

    // 创建小说
    const novel: Novel = {
        id: structure.rootFolder.id,
        name: structure.rootFolder.name,
        type: ItemType.NOVEL,
        fileHandle: structure.rootFolder,
        children: [],
        createdAt: new Date(),
        updatedAt: new Date()
    };

    // 注册小说根文件夹句柄
    console.log('注册小说根文件夹句柄:', structure.rootFolder.id, structure.rootFolder.name);
    registerFileHandle(structure.rootFolder.id, structure.rootFolder);

    // 添加卷和章节
    if (structure.volumes) {
        for (const volumeData of structure.volumes) {
            if (volumeData.folder) {
                const volume: Volume = {
                    id: volumeData.folder.id,
                    name: volumeData.folder.name,
                    type: ItemType.VOLUME,
                    fileHandle: volumeData.folder,
                    children: []
                };

                // 注册卷文件夹句柄
                console.log('注册卷文件夹句柄:', volumeData.folder.id, volumeData.folder.name);
                registerFileHandle(volumeData.folder.id, volumeData.folder);

                // 添加章节
                if (volumeData.chapters) {
                    for (const chapterData of volumeData.chapters) {
                        if (chapterData.file) {
                            // 注册章节文件句柄
                            console.log('注册章节文件句柄:', chapterData.file.id, chapterData.file.name);
                            registerFileHandle(chapterData.file.id, chapterData.file);

                            // 读取章节内容
                            let chapterContent = '';
                            try {
                                if (chapterData.content) {
                                    // 如果已有内容，直接使用
                                    chapterContent = chapterData.content;
                                } else {
                                    // 否则从文件中读取
                                    console.log(`读取章节文件内容: ${chapterData.file.name}`);
                                    // 使用文件句柄读取内容
                                    if (chapterData.file._handle) {
                                        const file = await chapterData.file._handle.getFile();
                                        const rawText = await file.text();
                                        chapterContent = preserveTextFormat(rawText);
                                    } else if (chapterData.file.path) {
                                        // Tauri环境使用路径
                                        if (window.__TAURI__) {
                                            const rawText = await window.__TAURI__.fs.readTextFile(chapterData.file.path);
                                            chapterContent = preserveTextFormat(rawText);
                                        }
                                    }
                                    console.log(`成功读取章节内容: ${chapterData.file.name}，长度: ${chapterContent.length}`);
                                }
                            } catch (error) {
                                console.error(`读取章节内容失败: ${chapterData.file.name}`, error);
                                // 失败时使用空内容
                                chapterContent = '';
                            }

                            const chapter: Chapter = {
                                id: chapterData.file.id,
                                name: chapterData.file.name.replace(/\.[^/.]+$/, ''), // 移除文件扩展名
                                type: ItemType.CHAPTER,
                                fileHandle: chapterData.file,
                                content: chapterContent
                            };

                            if (volume.children) {
                                volume.children.push(chapter);
                            }
                        }
                    }
                }

                // 只有当卷内有章节时才添加
                if (volume.children && volume.children.length > 0) {
                    novel.children?.push(volume);
                }
            }
        }
    }

    console.log('转换完成，小说:', novel.name, '卷数:', novel.children?.length || 0);
    return novel;
}

/**
 * 从小说获取关联的文件句柄
 * @param item 小说项
 * @returns 文件句柄或undefined
 */
export function getFileHandleFromItem(item: TreeItem): FileHandle | undefined {
    return (item as any).fileHandle;
}

/**
 * 为小说项设置文件句柄
 * @param item 小说项
 * @param handle 文件句柄
 */
export function setFileHandleForItem(item: TreeItem, handle: FileHandle): TreeItem {
    // 创建一个副本以避免直接修改原对象
    const updatedItem = { ...item };
    (updatedItem as any).fileHandle = handle;
    return updatedItem;
}

/**
 * 合并文件系统导入的小说与现有小说
 * 用于同步更新操作
 * @param original 原始小说
 * @param imported 导入的小说
 * @returns 合并后的小说
 */
export function mergeNovelWithImported(original: Novel, imported: Novel): Novel {
    // 保留原始ID和元数据，但更新结构
    return {
        ...original,
        name: imported.name,
        fileHandle: imported.fileHandle,
        children: imported.children || []
    };
}

/**
 * 从文件系统中提取文本内容
 * 读取章节文件内容
 * @param chapter 章节对象
 * @returns 章节内容Promise
 */
export async function extractChapterContent(chapter: Chapter): Promise<string> {
    try {
        if (!chapter.fileHandle) {
            console.log('章节没有文件句柄，返回已有内容');
            return chapter.content || '';
        }

        // 使用文件句柄读取内容
        try {
            console.log('从文件句柄读取章节内容');

            // 获取文件
            const file = await chapter.fileHandle._handle.getFile();

            // 读取文本内容并保留格式
            const rawContent = await file.text();
            const formattedContent = preserveTextFormat(rawContent);
            console.log('读取章节内容成功，长度:', formattedContent.length);

            return formattedContent;
        } catch (error) {
            console.error('从文件句柄读取章节内容失败:', error);
            // 失败时返回已有内容
            return chapter.content || '';
        }
    } catch (error) {
        console.error('读取章节内容失败:', error);
        return '';
    }
} 